import { ref, onMounted, watch, reactive } from 'vue';
// 导入Element Plus组件用于UI交互和消息提示
import { ElMessage, ElForm, ElMessageBox } from 'element-plus';
// 导入API服务层，实现业务逻辑与数据请求分离
import ctfContestApi from '@/api/Backend/CtfContestApi';

// 定义考试数据接口，提供类型约束确保数据结构一致性
interface CtfContest {
  contestId?: number;
  contestName: string;
  contestType: string;
  contestStatus: string;
  contestDifficulty: string;
  startTime: string;
  endTime: string;
  createTime: string;
  creator: string;
  updateTime: string;
  updater: string;
}

// 使用组合式函数封装考试管理相关的状态和方法
// 便于代码复用和维护，符合Vue3的Composition API最佳实践
export function useCtfContest() {
  // 考试列表数据，使用ref包装数组实现响应式
  // 采用单独的filteredList处理搜索过滤，避免直接修改原始数据
  const contestList = ref<CtfContest[]>([]);
  const filteredList = ref<CtfContest[]>([]);

  // 分页控制变量，使用ref包装基本类型实现响应式
  // 初始值设为1和10符合常见的分页默认配置
  const currentPage = ref(1);
  const pageSize = ref(10);

  // 搜索关键词，使用ref包装实现响应式
  const searchKeyword = ref('');

  // 删除状态标记，用于控制删除按钮加载状态
  const isDeleting = ref(false);

  // 对话框显示状态，控制新增/编辑考试对话框的显示与隐藏
  const dialogVisible = ref(false);

  // 表单引用，用于表单验证和提交
  const formRef = ref<InstanceType<typeof ElForm>>();

  // 编辑模式标记，区分新增和编辑操作
  const editMode = ref<'add' | 'edit'>('add');

  // 表单数据，使用reactive创建响应式对象
  // 初始值为空字符串，确保表单控件绑定正常
  const form = reactive<CtfContest>({
    contestId: undefined,
    contestName: '',
    contestType: '',
    contestStatus: '',
    contestDifficulty: '',
    startTime: '',
    endTime: '',
    createTime: '',
    creator: '',
    updateTime: '',
    updater: ''
  });

  // 表单校验规则，确保用户输入符合业务要求
  // 必填项验证防止空数据提交，提升系统健壮性
  const formRules = {
    contestName: [{ required: true, message: '请输入考试名称', trigger: 'blur' }],
    contestType: [{ required: true, message: '请输入考试类型', trigger: 'blur' }],
    contestStatus: [{ required: true, message: '请选择考试状态', trigger: 'change' }],
    contestDifficulty: [{ required: true, message: '请选择难度等级', trigger: 'change' }],
    startTime: [{ required: true, message: '请选择开始时间', trigger: 'change' }],
    endTime: [{ required: true, message: '请选择结束时间', trigger: 'change' }]
  };

  // 发布考试相关变量
  // 使用独立的ref控制抽屉显示状态，避免与其他模态框冲突
  const publishDrawerVisible = ref(false);
  // 存储靶场列表数据
  const publishRangeList = ref<any[]>([]);
  // 存储选中的靶场数据
  const selectedPublishRanges = ref<any[]>([]);
  // 当前操作的考试ID
  const selectedContestId = ref<number>(0);

  // 选择考生相关变量
  // 与发布考试使用独立状态，防止数据相互干扰
  const selectUserDrawerVisible = ref(false);
  const userList = ref<any[]>([]);
  const selectedUsers = ref<any[]>([]);

  // 打开发布考试抽屉
  // 接收考试行数据作为参数，初始化相关状态
  const openPublishDrawer = (row: CtfContest) => {
    selectedContestId.value = row.contestId as number;
    publishDrawerVisible.value = true;
    // 打开抽屉时立即加载靶场数据，确保数据最新
    fetchPublishRangeList();
    // 重置选择状态，避免残留上次选择的数据
    selectedPublishRanges.value = [];
  };

  // 获取靶场列表
  // 封装为独立方法便于复用和维护
  const fetchPublishRangeList = async () => {
    try {
      // 使用API服务层获取数据，统一管理请求逻辑
      const res = await ctfContestApi.getRangeList();
      // 严格验证响应格式，防止后端返回异常数据导致前端崩溃
      if (res && res.code === 200 && Array.isArray(res.data)) {
        publishRangeList.value = res.data;
      } else {
        // 数据格式异常时给予用户明确提示
        ElMessage.warning('靶场数据格式异常');
        publishRangeList.value = [];
      }
    } catch (err) {
      // 捕获网络错误并提示用户
      ElMessage.error('获取靶场列表失败');
      console.error('获取靶场列表错误:', err);
    }
  };

  // 处理靶场选择变化
  // 实时更新选中的靶场数据
  const handlePublishSelectionChange = (selection: any[]) => {
    selectedPublishRanges.value = selection;
  };

  // 处理发布关联
  // 批量关联考试和靶场
  const handlePublishRelate = async () => {
    // 前置校验，防止空选择提交
    if (selectedPublishRanges.value.length === 0) {
      ElMessage.warning('请选择至少一个靶场');
      return;
    }

    // 初始化统计变量，记录成功和失败数量
    let successCount = 0;
    let failCount = 0;
    const total = selectedPublishRanges.value.length;

    // 提示用户开始关联操作
    ElMessage({ message: `开始关联${total}个靶场...`, type: 'info' });

    // 使用for循环串行发送请求，避免同时发送大量请求导致后端压力过大
    for (const [index, range] of selectedPublishRanges.value.entries()) {
      try {
        // 调用API服务层方法提交数据
        const response = await ctfContestApi.addContestRangeRel({
          contestId: selectedContestId.value,
          rangeId: range.rangeId
        });

        // 根据后端返回状态码判断操作结果
        if (response.code === 200) {
          successCount++;
        } else {
          failCount++;
          console.error(`第${index + 1}个靶场关联失败:`, response.msg);
        }
      } catch (error) {
        failCount++;
        console.error(`第${index + 1}个靶场请求异常:`, error.message);
      }
    }

    // 操作完成后提示用户总体结果
    ElMessage.success(`关联完成: 成功${successCount}/${total}个，失败${failCount}个`);
    // 关闭抽屉
    publishDrawerVisible.value = false;
  };

  // 发布抽屉关闭前处理函数
  // 提供统一的关闭前处理入口，便于后续扩展
  const handlePublishDrawerClose = (done: () => void) => {
    done();
  };

  // 打开选择考生抽屉
  // 与发布考试抽屉类似的逻辑，处理考生选择
  const openSelectUserDrawer = (row: CtfContest) => {
    selectedContestId.value = row.contestId as number;
    selectUserDrawerVisible.value = true;
    fetchUserList();
    selectedUsers.value = [];
  };

  // 获取考生列表
  // 与获取靶场列表类似的逻辑
  const fetchUserList = async () => {
    try {
      const res = await ctfContestApi.getUserList();
      if (res && res.code === 200 && Array.isArray(res.data)) {
        userList.value = res.data;
      } else {
        ElMessage.warning('考生数据格式异常');
        userList.value = [];
      }
    } catch (err) {
      ElMessage.error('获取考生列表失败');
      console.error('获取考生列表错误:', err);
    }
  };

  // 处理考生选择变化
  const handleUserSelectionChange = (selection: any[]) => {
    selectedUsers.value = selection;
  };

  // 处理考生关联
  // 与靶场关联类似的批量处理逻辑
  const handleUserRelate = async () => {
    if (selectedUsers.value.length === 0) {
      ElMessage.warning('请选择至少一个考生');
      return;
    }

    let successCount = 0;
    let failCount = 0;
    const total = selectedUsers.value.length;

    ElMessage({ message: `开始关联${total}个考生...`, type: 'info' });

    for (const [index, user] of selectedUsers.value.entries()) {
      try {
        const response = await ctfContestApi.addUserContestRel({
          contestId: selectedContestId.value,
          userId: user.userId
        });

        if (response.code === 200) {
          successCount++;
        } else {
          failCount++;
          console.error(`第${index + 1}个考生关联失败:`, response.msg);
        }
      } catch (error) {
        failCount++;
        console.error(`第${index + 1}个考生请求异常:`, error.message);
      }
    }

    ElMessage.success(`关联完成: 成功${successCount}/${total}个，失败${failCount}个`);
    selectUserDrawerVisible.value = false;
  };

  // 考生抽屉关闭前处理函数
  const handleUserDrawerClose = (done: () => void) => {
    done();
  };

  // 获取考试列表
  // 页面初始化时调用，加载考试数据
  const fetchContestList = async () => {
    try {
      const res = await ctfContestApi.getContestList();
      if (res && res.code === 200) {
        contestList.value = res.data;
        filteredList.value = contestList.value;
      } else {
        ElMessage.warning('考试数据格式异常');
        contestList.value = [];
        filteredList.value = [];
      }
    } catch (err) {
      console.error('获取考试列表失败:', err);
      ElMessage.error('数据加载失败');
    }
  };

  // 搜索功能
  // 根据关键词过滤考试列表
  const handleSearch = () => {
    filteredList.value = contestList.value.filter(item => 
      item.contestName.includes(searchKeyword.value) || 
      item.contestType.includes(searchKeyword.value) ||
      item.contestStatus.includes(searchKeyword.value) ||
      item.contestDifficulty.includes(searchKeyword.value)
    );
    // 搜索后重置页码为1，符合用户预期
    currentPage.value = 1;
  };

  // 重置筛选
  // 恢复原始列表数据
  const resetFilter = () => {
    filteredList.value = contestList.value;
    currentPage.value = 1;
  };

  // 分页大小变化
  // 当每页条数变化时重置页码为1
  const handleSizeChange = (val: number) => {
    pageSize.value = val;
    currentPage.value = 1;
  };

  // 页码变化
  const handleCurrentChange = (val: number) => {
    currentPage.value = val;
  };

  // 打开弹框（新增/编辑）
  // 根据模式参数决定是新增还是编辑操作
  const openDialog = (mode: 'add' | 'edit', row?: CtfContest) => {
    editMode.value = mode;
    dialogVisible.value = true;
    if (mode === 'edit' && row) {
      // 编辑模式下复制行数据到表单
      Object.assign(form, row);
    } else {
      // 新增模式下重置表单
      form.contestName = '';
      form.contestType = '';
      form.contestStatus = '';
      form.contestDifficulty = '';
      form.startTime = '';
      form.endTime = '';
      form.createTime = '';
      form.creator = '';
      form.updateTime = '';
      form.updater = '';
    }
  };

  // 提交表单（新增/编辑）
  // 根据编辑模式决定调用新增还是更新API
  const submitForm = async () => {
    try {
      // 表单验证
      await formRef.value?.validate();
      if (editMode.value === 'add') {
        // 新增模式下，只提交必要的字段
        const submitData = {
          contestName: form.contestName,
          contestType: form.contestType,
          contestStatus: form.contestStatus,
          contestDifficulty: form.contestDifficulty,
          startTime: form.startTime,
          endTime: form.endTime,
        };
        const res = await ctfContestApi.addContest(submitData);
        if (res && res.code === 200) {
          ElMessage.success('新增成功');
          fetchContestList();
          dialogVisible.value = false;
        } else {
          ElMessage.error('新增失败: ' + (res?.msg || '未知错误'));
        }
      } else {
        // 编辑模式下提交完整表单数据
        const res = await ctfContestApi.updateContest(form);
        if (res && res.code === 200) {
          ElMessage.success('编辑成功');
          fetchContestList();
          dialogVisible.value = false;
        } else {
          ElMessage.error('编辑失败: ' + (res?.msg || '未知错误'));
        }
      }
    } catch (err) {
      console.error('提交表单失败:', err);
    }
  };

  // 删除考试
  // 包含确认提示，防止误操作
  const deleteContest = async (row: CtfContest) => {
    try {
      // 二次确认，防止误删除
      await ElMessageBox.confirm('确定要删除该考试吗？', '确认删除', {
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning',
      });

      isDeleting.value = true;
      const res = await ctfContestApi.deleteContest(row.contestId as number);
      if (res && res.code === 200) {
        ElMessage.success('删除成功');
        fetchContestList();
      } else {
        ElMessage.error('删除失败: ' + (res?.msg || '未知错误'));
      }
      isDeleting.value = false;
    } catch (err) {
      isDeleting.value = false;
      // 用户取消操作时不显示错误提示
      if (err !== 'cancel') {
        console.error('删除失败:', err);
        ElMessage.error('删除操作失败');
      }
    }
  };

  // 格式化日期
  // 统一日期显示格式
  const formatDate = (dateString: string) => {
    if (!dateString) return '';
    const date = new Date(dateString);
    return date.toLocaleString();
  };

  // 获取状态标签类型
  // 根据状态值返回对应的Element Plus标签类型，提升视觉体验
  const getStatusTagType = (status: string) => {
    switch (status) {
      case '未开始': return 'info';
      case '进行中': return 'success';
      case '已结束': return 'warning';
      case '已取消': return 'danger';
      default: return '';
    }
  };

  // 获取难度标签类型
  // 与状态标签类似，使用不同颜色区分难度级别
  const getDifficultyType = (difficulty: string) => {
    switch (difficulty) {
      case '初级': return 'success';
      case '中级': return 'warning';
      case '高级': return 'danger';
      default: return '';
    }
  };

  // 获取靶场难度标签类型
  // 处理数字类型的难度ID
  const getDifficultyTagType = (difficultyId: number) => {
    switch (difficultyId) {
      case 1: return 'success';
      case 2: return 'success';
      case 3: return 'warning';
      case 4: return 'warning';
      case 5: return 'danger';
      default: return '';
    }
  };

  // 格式化难度ID为文字
  // 将数字难度ID转换为用户友好的文字描述
  const formatDifficulty = (difficultyId: number) => {
    switch (difficultyId) {
      case 1: return '入门';
      case 2: return '简单';
      case 3: return '中等';
      case 4: return '困难';
      case 5: return '地狱';
      default: return '未知';
    }
  };

  // 初始化加载数据
  // 组件挂载时自动加载考试列表
  onMounted(() => fetchContestList());

  // 监听搜索关键词
  // 实现实时搜索功能，提升用户体验
  watch(searchKeyword, () => {
    searchKeyword.value ? handleSearch() : resetFilter();
  });

  // 返回状态和方法，供组件使用
  // 明确导出需要暴露的状态和方法，避免不必要的暴露
  return {
    // 状态变量
    contestList,
    filteredList,
    currentPage,
    pageSize,
    searchKeyword,
    isDeleting,
    dialogVisible,
    formRef,
    editMode,
    form,
    formRules,
    publishDrawerVisible,
    publishRangeList,
    selectedPublishRanges,
    selectedContestId,
    selectUserDrawerVisible,
    userList,
    selectedUsers,

    // 方法
    openPublishDrawer,
    fetchPublishRangeList,
    handlePublishSelectionChange,
    handlePublishRelate,
    handlePublishDrawerClose,
    openSelectUserDrawer,
    fetchUserList,
    handleUserSelectionChange,
    handleUserRelate,
    handleUserDrawerClose,
    fetchContestList,
    handleSearch,
    resetFilter,
    handleSizeChange,
    handleCurrentChange,
    openDialog,
    submitForm,
    deleteContest,
    formatDate,
    getStatusTagType,
    getDifficultyType,
    getDifficultyTagType,
    formatDifficulty
  };
}